package org.lep.leetcode.pathsum;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Source : https://oj.leetcode.com/problems/path-sum-ii/
 *
 * Created by lverpeng on 2017/8/15.
 *
 * Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.
 *
 * For example:
 * Given the below binary tree and sum = 22,
 *
 *               5
 *              / \
 *             4   8
 *            /   / \
 *           11  13  4
 *          /  \    / \
 *         7    2  5   1
 *
 * return
 *
 * [
 *    [5,4,11,2],
 *    [5,8,4,5]
 * ]
 *
 */
public class PathSum2 {


    /**
     *
     * 求出根节点到叶子节点的和等于sum的所有路径
     *
     * @param root
     * @param target
     * @return
     */
    public List<List<TreeNode>> pathSum (TreeNode root, int target) {
        List<List<TreeNode>> result = new ArrayList<List<TreeNode>>();
        List<TreeNode> path = new ArrayList<TreeNode>();
        pathSum(root, result, path, 0, target);
        return result;
    }

    public void pathSum (TreeNode root, List<List<TreeNode>> result, List<TreeNode> path, int sum, int target) {
        if (root == null) {
            if (sum == target) {
                List<TreeNode> list = new ArrayList<TreeNode>(path);
                result.add(list);
            }
            return ;
        }
        path.add(root);
        if (root.leftChild != null || root.rightChild != null) {
            // 如果左右子节点都为空只计算一个
            pathSum(root.leftChild, result, path, sum + root.value, target);
        }


        pathSum(root.rightChild, result, path, sum + root.value, target);
        path.remove(path.size()-1);

    }



    public TreeNode createTree (char[] treeArr) {
        TreeNode[] tree = new TreeNode[treeArr.length];
        for (int i = 0; i < treeArr.length; i++) {
            if (treeArr[i] == '#') {
                tree[i] = null;
                continue;
            }
            tree[i] = new TreeNode(treeArr[i]-'0');
        }
        int pos = 0;
        for (int i = 0; i < treeArr.length && pos < treeArr.length-1; i++) {
            if (tree[i] != null) {
                tree[i].leftChild = tree[++pos];
                if (pos < treeArr.length-1) {
                    tree[i].rightChild = tree[++pos];
                }
            }
        }
        return tree[0];
    }

    private static void print (List<List<TreeNode>> list) {
        for (List<TreeNode> nodes: list) {
            System.out.println(Arrays.toString(nodes.toArray(new TreeNode[nodes.size()])));
        }
        System.out.println();
    }


    private class TreeNode {
        TreeNode leftChild;
        TreeNode rightChild;
        int value;

        public TreeNode(int value) {
            this.value = value;
        }

        public TreeNode() {

        }

        @Override
        public String toString() {
            return value + "";
        }
    }

    public static void main(String[] args) {
        PathSum2 pathSum2 = new PathSum2();
        char[] arr0 = new char[]{'5','4','8','1','#','3','3','7','2','#','#','5','1'};

        print(pathSum2.pathSum(pathSum2.createTree(arr0), 12));
        print(pathSum2.pathSum(pathSum2.createTree(arr0), 17));
    }
}
